package org.example.serializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.example.pojo.RpcRequest;
import org.example.pojo.RpcResponse;

import java.io.IOException;

public class JsonSerializer implements Serializer {

    // 修正：变量名规范（无空格）、类名拼写（ObjectMapper）
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    /**
     * 序列化：将对象转为字节数组
     */
    // 修正：注解首字母大写
    public <T> byte[] serialize(T obj) throws IOException {  // 修正：异常类名大写（IOException）
        if (obj == null) {
            return new byte[0];
        }
        return OBJECT_MAPPER.writeValueAsBytes(obj);
    }

    /**
     * 反序列化：处理泛型擦除问题，确保RpcRequest/RpcResponse的参数类型正确
     */
    public <T> T deserialize(byte[] bytes, Class<T> classType) throws IOException {  // 修正：异常类名大写
        if (bytes == null || bytes.length == 0) {
            return null;
        }
        // 反序列化基础对象
        T obj = OBJECT_MAPPER.readValue(bytes, classType);

        // 处理RpcRequest的泛型参数类型
        if (obj instanceof RpcRequest) {
            return handleRequest((RpcRequest) obj, classType);
        }
        // 处理RpcResponse的泛型返回值类型
        if (obj instanceof RpcResponse) {
            return handleResponse((RpcResponse) obj, classType);
        }

        return obj;
    }

    /**
     * 修复RpcRequest中参数因泛型擦除导致的类型错误（如LinkedHashMap转实际类型）
     */
    private <T> T handleRequest(RpcRequest rpcRequest, Class<T> type) throws IOException {
        // 获取请求参数的实际类型数组（如String.class, Integer.class）
        Class<?>[] parameterTypes = rpcRequest.getParameterTypes();
        // 获取反序列化后的参数数组（可能是LinkedHashMap）
        Object[] args = rpcRequest.getParameters();

        if (parameterTypes == null || args == null || parameterTypes.length != args.length) {
            return type.cast(rpcRequest);  // 类型不匹配时直接返回原始对象
        }

        // 循环修正每个参数的类型
        for (int i = 0; i < parameterTypes.length; i++) {
            Class<?> targetType = parameterTypes[i];
            Object arg = args[i];

            // 如果当前参数类型与目标类型不匹配（如LinkedHashMap vs 实际类型），重新序列化再反序列化
            if (arg != null && !targetType.isAssignableFrom(arg.getClass())) {
                byte[] argBytes = OBJECT_MAPPER.writeValueAsBytes(arg);
                args[i] = OBJECT_MAPPER.readValue(argBytes, targetType);
            }
        }

        // 修正后的参数重新设置回RpcRequest
        rpcRequest.setParameters(args);
        return type.cast(rpcRequest);
    }

    /**
     * 修复RpcResponse中返回值因泛型擦除导致的类型错误
     */
    private <T> T handleResponse(RpcResponse rpcResponse, Class<T> type) throws IOException {
        // 获取响应数据的实际类型（假设RpcResponse有getDataType()方法返回数据类型）
        Class<?> dataType = rpcResponse.getDataType();
        if (dataType == null) {
            return type.cast(rpcResponse);
        }

        // 获取反序列化后的响应数据（可能是LinkedHashMap）
        Object data = rpcResponse.getData();
        if (data == null) {
            return type.cast(rpcResponse);
        }

        // 如果数据类型不匹配，重新序列化再反序列化到目标类型
        if (!dataType.isAssignableFrom(data.getClass())) {
            byte[] dataBytes = OBJECT_MAPPER.writeValueAsBytes(data);
            data = OBJECT_MAPPER.readValue(dataBytes, dataType);
            rpcResponse.setData(data);  // 修正后的数据重新设置回RpcResponse
        }

        return type.cast(rpcResponse);
    }

    public String getType() {
        return "json";  // 序列化器标识，配合SPI使用
    }
}